home *** CD-ROM | disk | FTP | other *** search
/ Nebula 1 / Nebula One.iso / Internet / WWW / analog / Source / sscanf.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-02-07  |  15.3 KB  |  741 lines
  1. /*** analog 1.9beta ***/
  2. /* Please read Readme.html, or http://www.statslab.cam.ac.uk/~sret1/analog/  */
  3.  
  4. /*** sscanf.c; functions to replace sscanf(), which is far too slow, in
  5.      certain specific cases ***/
  6.  
  7. #include "analhea2.h"
  8.  
  9. /*** Now the scanning routines ***/
  10.  
  11. int sscanf_date(char *inputline, int *date, int *monthno, int *year, int *hr,
  12.         int *min)
  13. {    /* scanning date from common/agent/referer log */
  14.  
  15.   extern int strtomonth();          /* in utils.c */
  16.  
  17.   register char *cin = inputline;
  18.   char *cout;
  19.   char month[4];
  20.   int i;
  21.  
  22.   if (!isdigit(*cin))
  23.     return(0);
  24.   else
  25.     *date = 10 * (*cin - '0');
  26.   cin++;
  27.   if (!isdigit(*cin))
  28.     return(0);
  29.   else
  30.     *date += (*cin - '0');
  31.  
  32.   /* read in month */
  33.   cin++;
  34.   if (*cin != '/')
  35.     return(1);
  36.   cin++;
  37.   cout = month;
  38.   for (i = 0; i < 3 && *cin != '\0'; i++) {
  39.     *cout = *cin;
  40.     cout++;
  41.     cin++;
  42.   }
  43.   if (*cin == '\0')
  44.     return(1);
  45.   *cout = '\0';
  46.   if ((*monthno = strtomonth(month)) == ERR)
  47.     return(1);
  48.  
  49.   /* read in year */
  50.   if (*cin != '/')
  51.     return(2);
  52.   cin++;
  53.   if (!isdigit(*cin))
  54.     return(2);
  55.   else
  56.     *year = 1000 * (*cin - '0');
  57.   cin++;
  58.   if (!isdigit(*cin))
  59.     return(2);
  60.   else
  61.     *year += 100 * (*cin - '0');
  62.   cin++;
  63.   if (!isdigit(*cin)) {
  64.     if (*cin != ':')
  65.       return(2);
  66.     else {     /* allow two digit years for Spyglass server */
  67.       *year /= 100;
  68.       *year += 1900;
  69.       if (*year < 1970)
  70.     *year += 100;
  71.     }
  72.   }
  73.   else {
  74.     *year += 10 * (*cin - '0');
  75.     cin++;
  76.     if (!isdigit(*cin))
  77.       return(2);
  78.     else
  79.       *year += (*cin - '0');
  80.     cin++;
  81.     if (*cin != ':')
  82.       return(3);
  83.   }
  84.  
  85.   /* read in hour */
  86.   cin++;
  87.   if (!isdigit(*cin))
  88.     return(3);
  89.   else
  90.     *hr = 10 * (*cin - '0');
  91.   cin++;
  92.   if (!isdigit(*cin))
  93.     return(3);
  94.   else
  95.     *hr += (*cin - '0');
  96.  
  97.   /* read in minute */
  98.   cin++;
  99.   if (*cin != ':')
  100.     return(4);
  101.   cin++;
  102.   if (!isdigit(*cin))
  103.     return(4);
  104.   else
  105.     *min = 10 * (*cin - '0');
  106.   cin++;
  107.   if (!isdigit(*cin))
  108.     return(4);
  109.   else
  110.     *min += (*cin - '0');
  111.  
  112.   /* don't read in second, but check it for correct form */
  113.   cin++;
  114.   if (*cin != ':')
  115.     return(4);
  116.   cin++;
  117.   if (!isdigit(*cin))
  118.     return(4);
  119.   cin++;
  120.   if (!isdigit(*cin))
  121.     return(4);
  122.  
  123.   return(5);
  124. }
  125.  
  126. int sscanf_olddate(char *inputline, int *date, int *monthno, int *year,
  127.            int *hr, int *min)
  128. {    /* the same thing for NCSA old-style and error logs */
  129.  
  130.   extern int strtomonth();          /* in utils.c */
  131.  
  132.   register char *cin = inputline;
  133.   char *cout;
  134.   char month[4];
  135.   int i;
  136.  
  137.   /* ignore day of week, so scan until next ' ' */
  138.   for (cin++; *cin != ' ' && *cin != '\0'; cin++)
  139.     ;
  140.   if (*cin == '\0')
  141.     return(0);
  142.  
  143.   /* read in month */
  144.   cin++;
  145.   cout = month;
  146.   for (i = 0; i < 3 && *cin != '\0'; i++) {
  147.     *cout = *cin;
  148.     cout++;
  149.     cin++;
  150.   }
  151.   if (*cin == '\0')
  152.     return(0);
  153.   *cout = '\0';
  154.   if ((*monthno = strtomonth(month)) == ERR)
  155.     return(1);
  156.  
  157.   /* read in date */
  158.   if (*cin != ' ')
  159.     return(1);
  160.   cin++;
  161.   if (!isdigit(*cin) && *cin != ' ')
  162.     return(1);
  163.   else if (*cin != ' ')
  164.     *date = 10 * (*cin - '0');
  165.   else
  166.     *date = 0;
  167.   cin++;
  168.   if (!isdigit(*cin))
  169.     return(1);
  170.   else
  171.     *date += (*cin - '0');
  172.  
  173.   /* read in hour */
  174.   cin++;
  175.   if (*cin != ' ')
  176.     return(2);
  177.   cin++;
  178.   if (!isdigit(*cin))
  179.     return(2);
  180.   else
  181.     *hr = 10 * (*cin - '0');
  182.   cin++;
  183.   if (!isdigit(*cin))
  184.     return(2);
  185.   else
  186.     *hr += (*cin - '0');
  187.  
  188.   /* read in minute */
  189.   cin++;
  190.   if (*cin != ':')
  191.     return(3);
  192.   cin++;
  193.   if (!isdigit(*cin))
  194.     return(3);
  195.   else
  196.     *min = 10 * (*cin - '0');
  197.   cin++;
  198.   if (!isdigit(*cin))
  199.     return(3);
  200.   else
  201.     *min += (*cin - '0');
  202.   
  203.   /* ignore second (but check format) */
  204.   cin++;
  205.   if (*cin != ':')
  206.     return(4);
  207.   cin++;
  208.   if (!isdigit(*cin))
  209.     return(4);
  210.   cin++;
  211.   if (!isdigit(*cin))
  212.     return(4);
  213.   cin++;
  214.   if (*cin != ' ')
  215.     return(4);
  216.  
  217.   /* read year */
  218.   cin++;
  219.   if (!isdigit(*cin))
  220.     return(4);
  221.   else
  222.     *year = 1000 * (*cin - '0');
  223.   cin++;
  224.   if (!isdigit(*cin))
  225.     return(4);
  226.   else
  227.     *year += 100 * (*cin - '0');
  228.   cin++;
  229.   if (!isdigit(*cin))
  230.     return(4);
  231.   else
  232.     *year += 10 * (*cin - '0');
  233.   cin++;
  234.   if (!isdigit(*cin))
  235.     return(4);
  236.   else
  237.     *year += (*cin - '0');
  238.   return(5);
  239. }
  240.  
  241. int sscanf_common(char *inputline, char hostn[MAXSTRINGLENGTH], int *date,
  242.           int *monthno, int *year, int *hr, int *min,
  243.           char filename[MAXSTRINGLENGTH],
  244.           char referer[MAXSTRINGLENGTH], char agent[MAXSTRINGLENGTH],
  245.           int *code, char bytestr[16], size_t preflength)
  246. {     /* scanning 'common' format logfile entries */
  247.   extern flag included();           /* in alias.c */
  248.  
  249.   extern flag bq, Bq, fq;
  250.   extern struct include *noexpandhead;
  251.  
  252.   register char *cin = inputline;      /* the character we are reading */
  253.   register char *cout;                 /* where we are putting it */
  254.   int i;
  255.  
  256.   /* read in hostname */
  257.   i = 0;
  258.   for (cout = hostn; *cin != ' ' && *cin != '\0' && i < MAXSTRINGLENGTH - 1;
  259.        cin++) { 
  260.     *cout = *cin;
  261.     cout++;
  262.     i++;
  263.   }
  264.   if (*cin != ' ')
  265.     return(0);
  266.   *cout = '\0';
  267.  
  268.   /* scan until next '[' */
  269.   for (cin++; *cin != '[' && *cin != '\0'; cin++)
  270.     ;
  271.   if (*cin == '\0')
  272.     return(1);
  273.  
  274.   /* read in date */
  275.   cin++;
  276.   if (sscanf_date(cin, date, monthno, year, hr, min) < 5)
  277.     return(1);
  278.   else
  279.     cin += 20;
  280.   
  281.   /* ignore timezone; so scan to next '"' */
  282.   for ( ; *cin != '"' && *cin != '\0'; cin++)
  283.     ;
  284.   if (*cin == '\0')
  285.     return(6);
  286.  
  287.   /* ignore method; so read to next ' ' */
  288.   for (cin++; *cin != ' ' && *cin != '\0'; cin++)
  289.     ;
  290.   if (*cin == '\0')
  291.     return(6);
  292.  
  293.   /* read in filename */
  294.   cin++;
  295.   i = 0;
  296.   for (cout = filename; *cin != ' ' && *cin != '\0' && *cin != '"' &&
  297.        *cin != '?' && i < MAXSTRINGLENGTH - 1 - preflength; cin++) {
  298.     *cout = *cin;
  299.     cout++;
  300.     i++;
  301.   }
  302.   *cout = '\0';
  303.   if (*cin == '?' && !included(filename, noexpandhead)) {  /* read in args */
  304.     for ( ; *cin != ' ' && *cin != '\0' && *cin != '"' &&
  305.      i < MAXSTRINGLENGTH - 1 - preflength; cin++) {
  306.       *cout = *cin;
  307.       cout++;
  308.       i++;
  309.     }
  310.     *cout = '\0';
  311.   }
  312.   if (*cin != ' ' && *cin != '"' && *cin != '?')
  313.     return(6);
  314.  
  315.   /* scan to next " */
  316.   for ( ; *cin != '"' && *cin != '\0' ; cin++)
  317.     ;
  318.   if (*cin == '\0')
  319.     return(7);
  320.  
  321.   /* read in return code; always 3 digits, or a - (successes; call them 299) */
  322.   cin++;
  323.   if (*cin != ' ')
  324.     return(7);
  325.   cin++;
  326.   if (!isdigit(*cin))
  327.     if (*cin == '-' && *(cin + 1) == ' ')
  328.       *code = 299;
  329.     else
  330.       return(7);
  331.   else {
  332.     *code = 100 * (*cin - '0');
  333.     cin++;
  334.     if (!isdigit(*cin))
  335.       return(7);
  336.     else
  337.       *code += 10 * (*cin - '0');
  338.     cin++;
  339.     if (!isdigit(*cin))
  340.       return(7);
  341.     else
  342.       *code += (*cin - '0');
  343.   }
  344.  
  345.   /* read in bytestr */
  346.   cin++;
  347.   if (*cin != ' ')
  348.     return (8);
  349.   cin++;
  350.   i = 0;
  351.   for (cout = bytestr; *cin != ' ' && *cin != '\n' && *cin != '\0' && i < 16;
  352.        cin++) {
  353.     *cout = *cin;
  354.     cout++;
  355.   }
  356.   *cout = '\0';
  357.  
  358.   /* Finally, try and read in referer and agent of NCSA combined format */
  359.   if (*cin != ' ' || (!fq && !bq && !Bq))
  360.     return(9);
  361.   if (*(++cin) != '"')
  362.     return(9);
  363.   i = 0;
  364.   cin++;
  365.   for (cout = referer; *cin != '\0' && *cin != '"' && i < MAXSTRINGLENGTH - 1;
  366.        cin++) {
  367.     *cout = *cin;
  368.     cout++;
  369.     i++;
  370.   }
  371.   *cout = '\0';
  372.   if (*cin != '"')
  373.     return(9);
  374.   if (*(++cin) != ' ')
  375.     return(10);
  376.   if (*(++cin) != '"')
  377.     return(10);
  378.   i = 0;
  379.   cin++;
  380.   for (cout = agent; *cin != '\0' && *cin != '"' && i < MAXSTRINGLENGTH - 1;
  381.        cin++) {
  382.     *cout = *cin;
  383.     cout++;
  384.     i++;
  385.   }
  386.   *cout = '\0';
  387.   if (*cin != '"')
  388.     return(10);
  389.   else
  390.     return(11);
  391.  
  392. }
  393.  
  394. int sscanf_ncsaold(char *inputline, char hostn[MAXSTRINGLENGTH], int *monthno,
  395.            int *date, int *hr, int *min, int *year,
  396.            char filename[MAXSTRINGLENGTH], size_t preflength)
  397. {    /* scanning NCSA old-style logfile entries */
  398.   extern flag included();           /* in alias.c */
  399.  
  400.   extern struct include *noexpandhead;
  401.  
  402.   register char *cin = inputline;   /* the character we are reading */
  403.   register char *cout;              /* where we are putting it */
  404.   int i;
  405.  
  406.   /* read in hostname */
  407.   i = 0;
  408.   for (cout = hostn; *cin != ' ' && *cin != '\0' && i < MAXSTRINGLENGTH - 1;
  409.        cin++) { 
  410.     *cout = *cin;
  411.     cout++;
  412.     i++;
  413.   }
  414.   if (*cin != ' ')
  415.     return(0);
  416.   *cout = '\0';
  417.  
  418.   /* scan until next '[' */
  419.   for (cin++; *cin != '[' && *cin != '\0'; cin++)
  420.     ;
  421.   if (*cin == '\0')
  422.     return(1);
  423.  
  424.   /* read in date */
  425.   cin++;
  426.   if (sscanf_olddate(cin, date, monthno, year, hr, min) < 5)
  427.     return(1);
  428.   else
  429.     cin += 24;
  430.  
  431.   /* ignore method, so skip to second space */
  432.   for ( ; *cin != ' ' && *cin != '\0'; cin++)
  433.     ;
  434.   if (*cin == '\0')
  435.     return(6);
  436.  
  437.   for (cin++; *cin != ' ' && *cin != '\0'; cin++)
  438.     ;
  439.   if (*cin == '\0')
  440.     return(6);
  441.  
  442.   /* finally, read in the filename */
  443.   cin++;
  444.   i = 0;
  445.   for (cout = filename; *cin != ' ' && *cin != '\n' && *cin != '?' &&
  446.        *cin != '\0' && i < MAXSTRINGLENGTH - 1 - preflength; cin++) {
  447.     *cout = *cin;
  448.     cout++;
  449.     i++;
  450.   }
  451.   *cout = '\0';
  452.   if (*cin == '?' && !included(filename, noexpandhead)) {  /* read in args */
  453.     for ( ; *cin != ' ' && *cin != '\0' && *cin != '"' &&
  454.      i < MAXSTRINGLENGTH - 1 - preflength; cin++) {
  455.       *cout = *cin;
  456.       cout++;
  457.       i++;
  458.     }
  459.     *cout = '\0';
  460.   }
  461.   return (7);
  462.  
  463. }
  464.  
  465. int sscanf_domains(char *inputline, char string1[MAXSTRINGLENGTH],
  466.            char string2[MAXSTRINGLENGTH])
  467. {   /* scanning the domains file */
  468.   register char *cin = inputline;
  469.   register char *cout;
  470.   int i;
  471.  
  472.   /* run past any white space */
  473.   while (*cin == ' ' || *cin == '\t')
  474.     cin++;
  475.  
  476.   /* if no strings on this line, return 0 */
  477.   if (*cin == '#' || *cin == '\n' || *cin == '\0')
  478.     return(0);
  479.  
  480.   /* otherwise fill up string 1; coerce domains to lower case */
  481.   i = 0;
  482.   for (cout = string1; *cin != ' ' && *cin != '\t' && *cin != '#' &&
  483.        *cin != '\0' && *cin != '\n' && i < MAXSTRINGLENGTH - 1; cin++) {
  484.     *cout = tolower(*cin);
  485.     cout++;
  486.     i++;
  487.   }
  488.  
  489.   /* is that the end of the line (maybe after some white space)? */
  490.   if (*cin == '#' || *cin == '\0' || *cin == '\n' || i == MAXSTRINGLENGTH - 1)
  491.     return(1);
  492.  
  493.   *cout = '\0';
  494.   cin++;
  495.  
  496.   while (*cin == ' ' || *cin == '\t')
  497.     cin++;
  498.  
  499.   if (*cin == '#' || *cin == '\n' || *cin == '\0')
  500.     return(1);
  501.  
  502.   /* otherwise fill up string 2 */
  503.   for (cout = string2; *cin != '#' && *cin != '\n' && *cin != '\0' &&
  504.        i < MAXSTRINGLENGTH - 1; cin++) {
  505.     *cout = *cin;
  506.     cout++;
  507.     i++;
  508.   }
  509.  
  510.   *cout = '\0';
  511.   return(2);
  512.  
  513. }
  514.  
  515. int sscanf_config(char *inputline, char string1[MAXSTRINGLENGTH],
  516.           char string2[MAXSTRINGLENGTH],
  517.           char string3[MAXSTRINGLENGTH])
  518. {   /* scanning the config file */
  519.   register char *cin = inputline;
  520.   register char *cout;
  521.   int i;
  522.  
  523.   /* run past any white space */
  524.   while (*cin == ' ' || *cin == '\t')
  525.     cin++;
  526.  
  527.   /* if no strings on this line, return 0 */
  528.   if (*cin == '#' || *cin == '\n' || *cin == '\0')
  529.     return(0);
  530.  
  531.   /* otherwise fill up string 1; convert arguments to upper case */
  532.   i = 0;
  533.   for (cout = string1; *cin != ' ' && *cin != '\t' && *cin != '#' &&
  534.        *cin != '\0' && *cin != '\n' && i < MAXSTRINGLENGTH - 1; cin++) {
  535.     *cout = *cin;
  536.     cout++;
  537.     i++;
  538.   }
  539.  
  540.   *cout = '\0';
  541.  
  542.   /* is that the end of the line (maybe after some white space)? */
  543.   if (*cin == '#' || *cin == '\0' || *cin == '\n' || i == MAXSTRINGLENGTH - 1)
  544.     return(1);
  545.  
  546.   cin++;
  547.  
  548.   while (*cin == ' ' || *cin == '\t')
  549.     cin++;
  550.  
  551.   if (*cin == '#' || *cin == '\n' || *cin == '\0')
  552.     return(1);
  553.  
  554.   /* if string 2 starts with a quote mark, fill up until the next quote
  555.      mark. Otherwise, just fill until the next space */
  556.  
  557.   if (*cin == '\'') {
  558.     cin++;
  559.     for (cout = string2; *cin != '\n' && *cin != '\0' && *cin != '\'' &&
  560.      i < MAXSTRINGLENGTH - 1; cin++) {
  561.       *cout = *cin;
  562.       cout++;
  563.       i++;
  564.     }
  565.   }
  566.   else if (*cin == '"') {
  567.     cin++;
  568.     for (cout = string2; *cin != '\n' && *cin != '\0' && *cin != '"' &&
  569.      i < MAXSTRINGLENGTH - 1; cin++) {
  570.       *cout = *cin;
  571.       cout++;
  572.       i++;
  573.     }
  574.   }
  575.   else {
  576.     for (cout = string2; *cin != '#' && *cin != '\n' && *cin != '\0' &&
  577.      *cin != ' ' && *cin != '\t' && i < MAXSTRINGLENGTH - 1; cin++) {
  578.       *cout = *cin;
  579.       cout++;
  580.       i++;
  581.     }
  582.   }
  583.  
  584.   *cout = '\0';
  585.  
  586.   /* is that the end of the line (maybe after some white space)? */
  587.   if (*cin == '#' || *cin == '\0' || *cin == '\n' || i == MAXSTRINGLENGTH - 1)
  588.     return(2);
  589.  
  590.   cin++;
  591.  
  592.   while (*cin == ' ' || *cin == '\t')
  593.     cin++;
  594.  
  595.   if (*cin == '#' || *cin == '\n' || *cin == '\0')
  596.     return(2);
  597.  
  598.   /* otherwise fill up string 3 */
  599.   if (*cin == '\'') {
  600.     cin++;
  601.     for (cout = string3; *cin != '\n' && *cin != '\0' && *cin != '\'' &&
  602.      i < MAXSTRINGLENGTH - 1; cin++) {
  603.       *cout = *cin;
  604.       cout++;
  605.       i++;
  606.     }
  607.   }
  608.   else if (*cin == '"') {
  609.     cin++;
  610.     for (cout = string3; *cin != '\n' && *cin != '\0' && *cin != '"' &&
  611.      i < MAXSTRINGLENGTH - 1; cin++) {
  612.       *cout = *cin;
  613.       cout++;
  614.       i++;
  615.     }
  616.   }
  617.   else {
  618.     for (cout = string3; *cin != '#' && *cin != '\n' && *cin != '\0' &&
  619.      *cin != ' ' && *cin != '\t' && i < MAXSTRINGLENGTH - 1; cin++) {
  620.       *cout = *cin;
  621.       cout++;
  622.       i++;
  623.     }
  624.   }
  625.  
  626.   *cout = '\0';
  627.  
  628.   /* is that the end of the line (maybe after some white space)? */
  629.   if (*cin == '#' || *cin == '\0' || *cin == '\n' || i == MAXSTRINGLENGTH - 1)
  630.     return(3);
  631.  
  632.   cin++;
  633.  
  634.   while (*cin == ' ' || *cin == '\t')
  635.     cin++;
  636.  
  637.   if (*cin == '#' || *cin == '\n' || *cin == '\0')
  638.     return(3);
  639.  
  640.   return(4);   /* we don't ever want to read a fourth string; just know if
  641.           there is one for error checking */
  642.  
  643. }
  644.  
  645.  
  646. int sscanf_referer(char *inputline, int *date, int *monthno, int *year,
  647.            int *hr, int *min, char from[MAXSTRINGLENGTH],
  648.            char to[MAXSTRINGLENGTH])
  649. {   /* scanning the referer log */
  650.     /* The format is "[date] from -> to". The [date] is optional. */
  651.  
  652.   extern flag included();           /* in alias.c */
  653.  
  654.   extern struct include *refexpandhead, *noexpandhead;
  655.  
  656.   register char *cin = inputline;
  657.   register char *cout;
  658.   int i;
  659.  
  660.   /* scan the date */
  661.   if (*cin == '[') {
  662.     cin++;
  663.     if (sscanf_date(cin, date, monthno, year, hr, min) < 5)
  664.       return(0);
  665.     else
  666.       cin += 20;
  667.     if (*cin != ']')
  668.       return(5);
  669.     if (*(++cin) != ' ')
  670.       return(5);
  671.     cin++;
  672.   }
  673.   else
  674.     *date = 0;   /* as marker */
  675.  
  676.   /* now fill up the from string */
  677.  
  678.   i = 0;
  679.   for (cout = from; *cin != ' ' && *cin != '\0' && *cin != '#' &&
  680.        *cin != '?' && i < MAXSTRINGLENGTH - 1; cin++) {
  681.     *cout = *cin;
  682.     cout++;
  683.     i++;
  684.   }
  685.   *cout = '\0';
  686.   if (*cin == '?' && included(from, refexpandhead)) {  /* read in args */
  687.     for ( ; *cin != ' ' && *cin != '\0' && *cin != '#' &&
  688.      i < MAXSTRINGLENGTH - 1; cin++) {
  689.       *cout = *cin;
  690.       cout++;
  691.       i++;
  692.     }
  693.     *cout = '\0';
  694.   }
  695.  
  696.   /* check at this point that the line syntax is ok */
  697.  
  698.   if (*cin == '#' || *cin == '?') {
  699.     while (*cin != ' ' && *cin != '\0')
  700.       cin++;
  701.   }
  702.  
  703.   if (*cin != ' ')
  704.     return(5);
  705.   cin++;
  706.   if (*cin != '-')
  707.     return(6);
  708.   cin++;
  709.   if (*cin != '>')
  710.     return(6);
  711.   cin++;
  712.   if (*cin != ' ')
  713.     return(6);
  714.   cin++;
  715.  
  716.   /* and the to string */
  717.  
  718.   i = 0;
  719.   for (cout = to; *cin != ' ' && *cin != '\0' && *cin != '\n'
  720.        && i < MAXSTRINGLENGTH - 1; cin++) {
  721.     *cout = *cin;
  722.     cout++;
  723.     i++;
  724.   }
  725.   *cout = '\0';
  726.   if (*cin == '?' && !included(to, noexpandhead)) {  /* read in args */
  727.     for ( ; *cin != ' ' && *cin != '\0' && i < MAXSTRINGLENGTH - 1; cin++) {
  728.       *cout = *cin;
  729.       cout++;
  730.       i++;
  731.     }
  732.     *cout = '\0';
  733.   }
  734.  
  735.   if (*cin != '\n')
  736.     return(6);
  737.   else
  738.     return(7);
  739.  
  740. }
  741.